// pages/profile/credits/credits.js
const { getImageUrl } = require('../../../utils/imageUtils.js');
const api = require('../../../utils/api.js');

Page({
  /**
   * 页面的初始数据
   */
  data: {
    // 积分信息（从后端获取）
    creditsInfo: {
      total: 0, // 总积分
      used: 0, // 已使用
      remaining: 0, // 剩余
      monthlyQuota: 0, // 月度配额
      nextResetDate: '2025-10-18', // 下次重置日期
      expireDate: '2025-12-31' // 过期日期
    },

    // 积分购买弹窗显示状态
    showCreditsPurchase: false,

    // 积分购买套餐（从后端加载）
    creditsPurchaseOptions: [],

    // 选中的积分套餐
    selectedCreditsPackage: null,

    // 是否为开发模式
    isDevelopmentMode: false,

    // 积分消耗规则（从后端加载）
    consumeRules: [],

    // 积分使用记录
    usageHistory: [
      {
        id: 1,
        type: 'ai_image',
        title: 'AI生图',
        description: '生成"美女"主题图片',
        cost: -10,
        time: '2024-09-18 15:30',
        status: 'completed'
      },
      {
        id: 2,
        type: 'ai_image', 
        title: 'AI生图',
        description: '生成"风景"主题图片',
        cost: -10,
        time: '2024-09-18 14:20',
        status: 'completed'
      },
      {
        id: 3,
        type: 'recharge',
        title: '套餐充值',
        description: '月度套餐赠送积分',
        cost: +600,
        time: '2024-09-18 10:00',
        status: 'completed'
      },
      {
        id: 4,
        type: 'ai_image',
        title: 'AI生图',
        description: '生成"动物"主题图片',
        cost: -10,
        time: '2024-09-17 20:15',
        status: 'completed'
      },
      {
        id: 5,
        type: 'ai_video',
        title: 'AI视频',
        description: '生成短视频',
        cost: -50,
        time: '2024-09-17 16:45',
        status: 'completed'
      }
    ]
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log('积分页面加载');
    this.loadCreditsInfo();
    this.loadUsageHistory();
    this.loadConsumptionRules();
    
    // 设置开发模式状态
    this.setData({
      isDevelopmentMode: this.isDevelopmentMode()
    });
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 刷新积分信息
    this.loadCreditsInfo();
  },

  /**
   * 加载积分消耗规则
   */
  async loadConsumptionRules() {
    try {
      const response = await api.getCreditsConsumptionRules();
      if (response.success && response.data) {
        this.setData({
          consumeRules: response.data
        });
        console.log('积分消耗规则加载成功', response.data.length, '条规则');
      } else {
        console.error('获取积分消耗规则失败:', response.message);
        // 使用默认规则数据
        this.setData({
          consumeRules: [
            {
              type: 'ai_image',
              name: 'AI生图',
              cost: 10,
              unit: '积分/次',
              description: '生成1-3张高清AI图片',
              icon: 'photo-o'
            },
            {
              type: 'ai_video',
              name: 'AI视频',
              cost: 50,
              unit: '积分/次', 
              description: '生成短视频内容',
              icon: 'video-o'
            },
            {
              type: 'hd_enhance',
              name: '高清增强',
              cost: 5,
              unit: '积分/次',
              description: '图片高清增强处理',
              icon: 'diamond-o'
            }
          ]
        });
      }
    } catch (error) {
      console.error('加载积分消耗规则失败:', error);
      // 保持默认数据
    }
  },

  /**
   * 返回上一页
   */
  onBack() {
    wx.navigateBack();
  },

  /**
   * 加载积分信息
   */
  async loadCreditsInfo() {
    try {
      const response = await api.getCreditsInfo();
      if (response.success) {
        this.setData({
          creditsInfo: response.data
        });
        console.log('积分信息加载成功', response.data);
      } else {
        console.error('获取积分信息失败:', response.message);
      }
    } catch (error) {
      console.error('加载积分信息失败:', error);
      // 如果API调用失败，使用默认数据
      console.log('使用默认积分数据');
    }
  },

  /**
   * 加载使用记录
   */
  async loadUsageHistory() {
    try {
      const response = await api.getCreditsHistory({ page: 1, size: 50 });
      if (response.success && response.data.records) {
        // 转换后端数据格式为前端需要的格式
        const historyList = response.data.records.map(record => ({
          id: record.id,
          type: record.sourceType,
          title: this.getTransactionTitle(record.transactionType, record.sourceType),
          description: record.description,
          cost: record.amount, // 后端已经处理好正负号
          time: this.formatTime(record.createTime),
          status: record.status
        }));
        
        this.setData({
          usageHistory: historyList
        });
        console.log('积分使用记录加载成功', historyList.length, '条记录');
      } else {
        console.error('获取积分使用记录失败:', response.message);
      }
    } catch (error) {
      console.error('加载积分使用记录失败:', error);
      // 如果API调用失败，保持默认数据
      console.log('使用默认使用记录数据');
    }
  },

  /**
   * 获取交易标题
   */
  getTransactionTitle(transactionType, sourceType) {
    const titleMap = {
      'purchase': '积分充值',
      'consume': {
        'ai_image': 'AI生图',
        'ai_video': 'AI视频',
        'hd_enhance': '高清增强'
      },
      'earn': '积分获得',
      'gift': '积分赠送'
    };
    
    if (transactionType === 'consume' && typeof titleMap[transactionType] === 'object') {
      return titleMap[transactionType][sourceType] || '积分消费';
    }
    
    return titleMap[transactionType] || '积分变动';
  },

  /**
   * 格式化时间
   */
  formatTime(timeString) {
    if (!timeString) return '';
    
    const date = new Date(timeString);
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const hours = String(date.getHours()).padStart(2, '0');
    const minutes = String(date.getMinutes()).padStart(2, '0');
    
    return `${year}-${month}-${day} ${hours}:${minutes}`;
  },

  /**
   * 充值积分 - 弹出积分购买弹窗
   */
  async rechargeCredits() {
    try {
      // 加载积分套餐
      await this.loadCreditsPackages();
      
      this.setData({
        showCreditsPurchase: true
      });
    } catch (error) {
      console.error('加载积分套餐失败:', error);
      wx.showToast({
        title: '加载套餐失败',
        icon: 'none'
      });
    }
  },

  /**
   * 加载积分套餐
   */
  async loadCreditsPackages() {
    try {
      const response = await api.getCreditsPackages();
      if (response.success && response.data) {
        // 转换后端数据格式为前端需要的格式
        const packages = response.data.map(pkg => ({
          id: pkg.id,
          credits: pkg.creditsAmount,
          price: pkg.price,
          popular: pkg.isPopular,
          discount: pkg.discountLabel
        }));
        
        this.setData({
          creditsPurchaseOptions: packages
        });
        console.log('积分套餐加载成功', packages.length, '个套餐');
      } else {
        console.error('获取积分套餐失败:', response.message);
        // 使用默认套餐数据
        this.setData({
          creditsPurchaseOptions: [
            { id: 1, credits: 500, price: 50, popular: false },
            { id: 2, credits: 750, price: 75, popular: false },
            { id: 3, credits: 1500, price: 150, popular: false },
            { id: 4, credits: 2250, price: 223, popular: true, discount: '最划算' },
            { id: 5, credits: 4500, price: 450, popular: false },
            { id: 6, credits: 9000, price: 899, popular: false, discount: '超值' }
          ]
        });
      }
    } catch (error) {
      console.error('加载积分套餐异常:', error);
      throw error;
    }
  },

  /**
   * 关闭积分购买弹窗
   */
  closeCreditsPurchase() {
    this.setData({
      showCreditsPurchase: false,
      selectedCreditsPackage: null
    });
  },

  /**
   * 选择积分套餐
   */
  selectCreditsPackage(event) {
    const packageInfo = event.currentTarget.dataset.package;
    this.setData({
      selectedCreditsPackage: packageInfo
    });
  },

  /**
   * 确认购买积分
   */
  async confirmPurchase() {
    const { selectedCreditsPackage } = this.data;
    
    if (!selectedCreditsPackage) {
      wx.showToast({
        title: '请选择积分套餐',
        icon: 'none'
      });
      return;
    }

    try {
      wx.showLoading({ title: '创建订单...' });
      
      // 创建积分购买订单
      const orderResponse = await api.createCreditsOrder(selectedCreditsPackage.id, 'wechat');
      
      if (orderResponse.success) {
        wx.hideLoading();
        
        // 发起微信支付
        const paymentResult = await this.requestWechatPayment(orderResponse.data);
        
        if (paymentResult.success) {
          wx.showToast({
            title: '充值成功',
            icon: 'success'
          });
          
          // 关闭弹窗
          this.closeCreditsPurchase();
          
          // 刷新积分信息
          setTimeout(() => {
            this.loadCreditsInfo();
            this.loadUsageHistory();
          }, 1000);
        }
      } else {
        wx.showToast({
          title: orderResponse.message || '创建订单失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('购买积分失败:', error);
      wx.showToast({
        title: '充值失败，请稍后重试',
        icon: 'none'
      });
    } finally {
      wx.hideLoading();
    }
  },

  /**
   * 发起微信支付
   */
  async requestWechatPayment(orderData) {
    const { orderNo, amount } = orderData;
    
    // 生成支付参数（实际项目中应该从后端获取）
    const paymentParams = {
      timeStamp: String(Date.now()),
      nonceStr: this.generateNonceStr(),
      package: `prepay_id=${orderNo}_mock`,
      signType: 'RSA',
      paySign: 'mock_pay_sign'
    };

    return new Promise((resolve, reject) => {
      // 在开发阶段，使用模拟支付确认对话框
      wx.showModal({
        title: '确认支付',
        content: `确认购买${this.data.selectedCreditsPackage.credits}积分，支付¥${amount}？\n\n(开发阶段模拟支付)`,
        confirmText: '确认支付',
        cancelText: '取消',
        success: async (res) => {
          if (res.confirm) {
            try {
              wx.showLoading({ title: '支付处理中...' });
              
              // 模拟支付成功，调用支付回调
              const callbackResponse = await api.handleCreditsPaymentCallback(orderNo, {
                transactionId: 'mock_transaction_' + Date.now()
              });
              
              if (callbackResponse.success) {
                resolve({ success: true });
              } else {
                reject(new Error('支付回调处理失败'));
              }
            } catch (error) {
              reject(error);
            } finally {
              wx.hideLoading();
            }
          } else {
            resolve({ success: false });
          }
        }
      });
      
      // 生产环境中使用真实微信支付
      // wx.requestPayment({
      //   ...paymentParams,
      //   success: async (res) => {
      //     console.log('支付成功:', res);
      //     try {
      //       // 处理支付成功回调
      //       const callbackResponse = await api.handleCreditsPaymentCallback(orderNo, res);
      //       if (callbackResponse.success) {
      //         resolve({ success: true });
      //       } else {
      //         reject(new Error('支付回调处理失败'));
      //       }
      //     } catch (error) {
      //       reject(error);
      //     }
      //   },
      //   fail: (err) => {
      //     console.error('支付失败:', err);
      //     if (err.errMsg !== 'requestPayment:fail cancel') {
      //       wx.showToast({
      //         title: '支付失败',
      //         icon: 'none'
      //       });
      //     }
      //     reject(err);
      //   }
      // });
    });
  },

  /**
   * 生成随机字符串
   */
  generateNonceStr() {
    return Math.random().toString(36).substr(2, 15);
  },

  /**
   * 查看积分规则
   */
  viewRules() {
    // 开发模式下显示测试功能
    if (this.isDevelopmentMode()) {
      wx.showActionSheet({
        itemList: ['查看积分规则', '🔧 添加测试积分(1000)', '🔧 重置积分为0', '🔧 添加少量积分(50)'],
        success: (res) => {
          switch(res.tapIndex) {
            case 0:
              this.showRulesModal();
              break;
            case 1:
              this.addTestCredits(1000);
              break;
            case 2:
              this.resetTestCredits();
              break;
            case 3:
              this.addTestCredits(50);
              break;
          }
        }
      });
    } else {
      this.showRulesModal();
    }
  },

  /**
   * 显示积分规则弹窗
   */
  showRulesModal() {
    wx.showModal({
      title: '积分使用规则',
      content: '• AI生图：10积分/次\n• AI视频：50积分/次\n• 高清增强：5积分/次\n• 积分有效期：购买后1年内有效\n• 月度套餐：每月重置积分配额',
      showCancel: false,
      confirmText: '知道了'
    });
  },

  /**
   * 判断是否为开发模式
   */
  isDevelopmentMode() {
    // 可以通过多种方式判断，这里简单判断是否为开发者工具
    return wx.getSystemInfoSync().platform === 'devtools';
  },

  /**
   * 开发测试：添加积分
   */
  async addTestCredits(amount = 1000) {
    try {
      wx.showLoading({ title: '添加积分中...' });
      const response = await api.addTestCredits(amount);
      
      if (response.success) {
        wx.showToast({
          title: `成功添加${amount}积分`,
          icon: 'success'
        });
        
        // 刷新积分信息
        setTimeout(() => {
          this.loadCreditsInfo();
          this.loadUsageHistory();
        }, 1000);
      } else {
        wx.showToast({
          title: '添加失败：' + response.message,
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('添加测试积分失败:', error);
      wx.showToast({
        title: '添加失败，请稍后重试',
        icon: 'none'
      });
    } finally {
      wx.hideLoading();
    }
  },

  /**
   * 开发测试：重置积分
   */
  async resetTestCredits() {
    try {
      wx.showLoading({ title: '重置积分中...' });
      const response = await api.resetTestCredits(0);
      
      wx.showToast({
        title: '积分已重置，请手动刷新',
        icon: 'success'
      });
      
      // 提示用户手动刷新
      setTimeout(() => {
        this.loadCreditsInfo();
        this.loadUsageHistory();
      }, 1000);
    } catch (error) {
      console.error('重置积分失败:', error);
      wx.showToast({
        title: '重置失败',
        icon: 'none'
      });
    } finally {
      wx.hideLoading();
    }
  },

  /**
   * 分享给好友
   */
  onShareAppMessage() {
    return {
      title: '我的积分 - AI伙伴',
      path: '/pages/profile/credits/credits',
      imageUrl: getImageUrl('credits-share.png')
    };
  },

  /**
   * 分享到朋友圈
   */
  onShareTimeline() {
    return {
      title: '查看我的AI积分使用情况',
      imageUrl: getImageUrl('credits-timeline.png')
    };
  },

  /**
   * 下拉刷新
   */
  onPullDownRefresh() {
    Promise.all([
      this.loadCreditsInfo(),
      this.loadUsageHistory()
    ]).finally(() => {
      wx.stopPullDownRefresh();
    });
  }
});
